Enhancing the debugger stack with recently reported errors under debug

ABSTRACT

Method and apparatus for enhancing an executable is disclosed herein. In one embodiment, the method includes instrumenting an executable with additional program code to detect run-time errors, and while running the instrumented executable within a debug environment generating the run-time errors detected by the additional program code, upon reaching a breakpoint, identifying any of the run-time errors which occurred while executing a function in which the breakpoint is located, and transmitting an indication of the identified run-time errors to the debugging environment.

BACKGROUND

The present invention relates to debugging an executable at runtime toprovide additional data to a debugger and a dynamic analysis tool, andmore specifically, to generating dynamic analysis errors in anexecutable in the context of a debugger.

An issue in developing software is that the quality of code is dependenton many factors, such as the skill level of the developers, the qualityof testing, and the sufficient time to test every path of code. Intoday's competitive market, the time to design, generate, and test codeis constantly shrinking, while the time to fix problems within the codeis becoming increasingly more critical. There is a need to providebetter tools for developers to help speed the diagnostic process andhelp developers become more proactive at looking for potential problemareas before issues arise in the field.

Dynamic analysis tools, such as PurifyPlus™, available from UNICOMSystems, Inc., provide a toolset that improves the reliability ofsoftware applications by identifying difficult to find memory errors,such as uninitialized memory access, buffer overflow, and improperfreeing of memory. A limitation of dynamic analysis tools, however, iswhen the dynamic analysis tools are used on existing executables for thefirst time. In such cases, the dynamic analysis tools may detectnumerous errors that have been in the code for a long time. Depending onthe size of the code, and the number of revisions, versions, or relatedsystems, the dynamic analysis tool may detect hundreds, if notthousands, of issues. Many of the errors identified by the dynamicanalysis tools may be harmless or very unlikely to disrupt overallprogram operation or result in incorrect computing results, and thus,may not worth the time to fix. In any case, the sheer number of errorscan overwhelm a developer. More importantly, the sheer number of errorscan make it very difficult for a developer to determine which errors arerelated to the particular problem the developer is trying to fixaddress, especially when the developer is under pressure to fix theproblem quickly.

SUMMARY

According to one embodiment of the present invention, a method forenhancing debugging of an executable is disclosed herein. The methodincludes instrumenting an executable with additional program code todetect run-time errors, and while running the instrumented executablewithin a debug environment generating the run-time errors detected bythe additional program code, upon reaching a breakpoint, identifying anyof the run-time errors which occurred while executing a function inwhich the breakpoint is located, and transmitting an indication of theidentified run-time errors to the debugging environment.

According to one embodiment of the present invention, a system isdisclosed herein. The system includes a processor and a memory storingprogram code, which, when executed on the processor, performs anoperation of enhancing the debugging of an executable. The operationincludes instrumenting an executable with additional program code todetect run-time errors, and while running the instrumented executablewithin a debug environment generating the run-time errors detected bythe additional program code, upon reaching a breakpoint, identifying anyof the run-time errors which occurred while executing a function inwhich the breakpoint is located, and transmitting an indication of theidentified run-time errors to the debugging environment.

According to one embodiment of the present invention, a computer programproduct for enhancing debugging of an executable is disclosed herein.The computer program product includes a computer-readable storage mediumhaving computer-readable program code embodied therewith. Thecomputer-readable program code includes computer-readable program codeconfigured to instrument an executable with additional program code todetect run-time errors and while running the instrumented executablewithin a debug environment, computer-readable program code configured togenerate the run-time errors detected by the additional program code,computer-readable program code configured to identify any of therun-time errors which occurred while executing a function in which abreakpoint is located upon reaching the breakpoint, andcomputer-readable program code configured to transmit an indication ofthe identified run-time errors to the debugging environment.

BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS

So that the manner in which the above recited features of the presentdisclosure can be understood in detail, a more particular description ofthe disclosure, briefly summarized above, may be referenced byembodiments, some of which are illustrated in the appended drawings. Itis to be noted, however, that the appended drawings illustrate onlytypical embodiments of this disclosure and are therefore not to beconsidered limiting of its scope, for the disclosure may admit to otherequally effective embodiments.

FIG. 1 illustrates a computing environment, according to one embodimentdisclosed herein.

FIG. 2 illustrates a dynamic analysis tool, according to one embodimentdisclosed herein.

FIG. 3 illustrates a debugger, according to one embodiment disclosedherein.

FIG. 4 illustrates a stack frame, according to one embodiment disclosedherein.

FIG. 5 illustrates a method for using the dynamic analysis tool,according to one embodiment disclosed herein.

FIG. 6 illustrates a method for debugging an executable, according toone embodiment disclosed herein.

FIG. 7 illustrates a method for debugging an instrumented executable,according to one embodiment disclosed herein.

FIG. 8 illustrates a method for debugging an instrumented executable,according to another embodiment disclosed herein.

FIG. 9 illustrates a method for debugging an instrument executable,according to yet another embodiment disclosed herein.

FIG. 10 illustrates a computing system, according to one embodimentdisclosed herein.

For clarity, identical reference numerals have been used, whereapplicable, to designate identical elements that are common betweenfigures. Additionally, elements of one embodiment may be adapted for usewith other embodiments.

DETAILED DESCRIPTION

Embodiments presented herein describe techniques for enhancing thedebugging of an executable using dynamic analysis tool and a debugger.In one embodiment, the dynamic analysis tool instruments an executablewith additional program code to obtain information about the executableat run-time. The instrumented executable is then run in a debugenvironment. A debugger presents the errors detected by the instrumentedcode in context of a given debug session state.

In one embodiment, the dynamic analysis tool instruments the executablewith additional executable code that detects certain run-time errorswhen the instrumented code is executed. The dynamic analysis tool mayhave dynamic analysis parameters set before the analysis begins. Forexample, the dynamic analysis tool may be configured to detect onlycertain errors, such as memory leaks. Breakpoints may be set so that thedeveloper can halt the executable at certain points during the analysis.The dynamic analysis tool instruments the executable with additionalexecutable code to detect errors in the executable.

In one embodiment, the debugger provides the run-time errors generatedduring run-time in the context of a debug environment. The debugger mayhave parameters set before debugging of the instrumented executablebegins. For example, the debugger may only provide certain dynamicanalysis errors in the context of a debug environment. The debuggerselects an instrumented executable for debugging. The developer may setbreakpoints within the code to halt execution of the program atspecified locations. For example, the developer may want to setbreakpoints after a certain call sequence in the instrumentedexecutable. The instrumented executable is then executed in the debugenvironment. In one embodiment, debugging of the executable may includeadvanced data flow analysis to provide a more detailed analysis of therun-time errors.

While the current level of integration between dynamic analysis toolsand a debugger is helpful, it does not adequately help the userdetermine which errors detected by the dynamic analysis tool are relatedto a particular issue. Embodiments presented herein provide techniquesfor better integrating a dynamic analysis tool and a debugger. Morespecifically, embodiments presented herein integrate certaincapabilities of the dynamic analysis tool with a debugger to assistdevelopers in identifying specific issues that may be causing theproblem they are trying to debug.

The disclosure tracks issues by instrumenting debuggable code with adynamic analysis tool. Once a program under test (PUT) is instrumented,the debugger will detect errors in the PUT at execution. For thisdisclosure, errors occurring within a particular function and stackframe are tracked and associated with that routine and stack frame. Whenan error is detected, the stack display in a debugging interface isupdated to show the developer what calling routines had problemsdetected by the instrumented code, prior to execution reaching thecurrent breakpoint. Doing so allows developers to quickly determine whaterrors detected by the instrumentation may be related to the problemthey are seeing.

FIG. 1 illustrates an example computing environment 100, according toone embodiment. For example, the computing environment 100 includes acomputing system 105, a network 120, and a database 130 storing projectfiles 125. Illustratively, the computing system 105 includes a debugger110 and a dynamic analysis tool 115.

The dynamic analysis tool 115 is an application generally configured toinstrument executables, such as one of the project file 125 in database130. The dynamic analysis tool 115 provides a toolset that improves thereliability of executables by identifying difficult to find memoryerrors, such as uninitialized memory access, buffer overflow, andimproper freeing of memory. To do so, the analysis tool 115 instrumentsan executable program with additional code that, while generallytransparent to the operations of the executable, detects and reports oncertain errors or problems identified at runtime. The dynamic analysistool 115 may be used while building an executable or on an existingexecutable.

The debugger 110 is an application generally configured to test and/ordebug other executables, such as one of the project files 125 indatabase 130. The debugger 110 allows the developer to diagnose andcorrect problems that occur during runtime. For example, a developer canuse the debugger 110 to insert breakpoints at locations in a programwhere the program crashes or where the program does not produce thecorrect results.

In the computing environment 100, the dynamic analysis tool 115 workswith the debugger 110 to assist developers in zeroing in on potentialissues that may be causing a problem the developer is trying to debug.To do this, the dynamic analysis tool 115 instruments the executablewith additional executable code to detect errors at runtime. Thedebugger 110 will provide the errors found by the instrumented code inthe context of a debug environment.

FIG. 2 illustrates the dynamic analysis tool 115, according to oneembodiment. As shown, the dynamic analysis tool 115 includes an analysistool engine 200, an instrumented code generator 205, analysis parameters210, an analysis log component 220, and an analysis log 225. Theinstrumented code generator 205 instruments the executable with code todetect memory leaks, uninitialized memory access, or line-level andfunction level code coverage. At run-time, the instrumented code in theexecutable may report this to the analysis tool engine 200. The analysisparameters 210 allow the user to customize the instrumented codegenerator 205 such that the additional program code detects only desirederrors. For example, the analysis parameters 210 may be set such thatthe additional program code detects only memory leaks. The analysis logcomponent 220 records errors detected at runtime in the analysis log225.

FIG. 3 illustrates the debugger 110, according to one embodiment. Asshown, the debugger 110 includes a detection component 305, a breakpointcomponent 310, a data flow analysis component 315, a log component 320,and a debug log 325. The detection component 305 reports information onerrors detected by the instrumented code in the context of the debuggingenvironment. The log component 320 records the errors detected in anexecutable in the debug log 325 for the currently executing routine at acurrent stack frame. For example, a record containing an addressassociated with the error may be updated. The record provides thisinformation to the debugger so that the debugger may display thisinformation. The breakpoint component 310 allows the user to setbreakpoints for the detection component 305. For example, the user maywant to set a breakpoint before, during, or after a specific routine orspecific stack frame. When the PUT halts execution at a breakpoint, thedebugger can present information related to errors identified by theinstrumented code and the dynamic analysis tool. For example, in oneembodiment, the debugger presents any error detected in the executingroutine of the breakpoint. Further, a developer can browse routines onthe program stack to identify errors detected in the PUT in routinesexecuted prior to the current one. The data flow analysis component 315works with the detection component 305 to provide a more detailedanalysis of an error detected.

Referring to FIG. 4, FIG. 4 illustrates an example stack 400 in aninstrumented executable under analysis in the debugger 110. As shown,stack 400 includes frames calls to function F(A) 405, function F(B) 410,and function F(C) 415. F(A) 405, F(B) 410, and F(C) 415 include dynamicanalysis errors found by the analysis tool engine 200 that occurredwhile executing the instrumented executable. In this example, F(A) 405calls F(B) 410; F(B) 410 calls F(C) 415; and F(C) 415 returns to F(B)410 without hitting a breakpoint. Because F(C) 415 returns to F(B) 410,F(C)'s 415 entry was popped off the stack, and all records for F(C) 415are discarded. Thus, when the user looks into the debug log 325 to seethe errors associated with the frame stack 400, the user will not seethe errors associated with F(C) 415. This is problematic because theerror associated with F(C) 415 may have caused the errors associatedwith F(A) 405 and F(B) 410, respectively. The data flow analysiscomponent 315 can fix this issue by keeping track of those variables orfunctions that may affect later computation in the current stack. Thus,using data flow analysis component 315 in conjunction with the detectioncomponent 305 can detect more complex errors that are written to therecords associated with the runtime routine in a stack.

FIG. 5 illustrates a method 500 for using the dynamic analysis tool 115,according to one embodiment. The method 500 begins at step 502 where theanalysis parameters 210 are defined. As noted, the analysis parametersspecify a scope of errors the instrumented executable should generate atruntime. At step 504, an executable is selected for analysis. At step506, the instrumented code generator 205 instruments the selectedexecutable, i.e., the program under test (PUT) with additional programcode to detect the errors specified in the analysis parameters at step502. The additional program code in the executable identifies errorspresent in the executable. At step 508, the instrumented executable,i.e. PUT, is opened in a debugging environment for execution.

FIG. 6 illustrates a block diagram of a method 600 for debugging anexecutable instrumented to detect certain dynamic run time errors,according to one embodiment. At step 602 the debugger 110 is launched.At step 604, the debug parameters are defined in the debugger 110. Forexample, a developer may use the breakpoint component 310 provided bythe debugger to specify breakpoints at which the execution of theinstrumented executable should be halted. Such breakpoints can beunconditional or depend on a set of conditions (e.g., halt on reachingan instruction if a given variable has a specified value). At step 606,the instrumented executable runs in the debugger. The debugger willprovide, among other things, the dynamic analysis errors detected by theadditional program code in the context of the debugger. As theinstrumented executable runs in the debugger, if the detection component305 detects an error in the instrumented executable, the record for thecurrently executing routine in the instrumented executable is updated tosave the error and any address that may have been associated with theerror. At step 608, the instrumented executable resumes running, andexecution continues as normal. When a routine returns, instrumentationcode at the return point gets control, and frees up the record for thisroutine and stack frame. Whenever the stack display is updated, the listof routines and stack frames are accessed. For each entry on the stack,the user can access the list and determine if any errors have beendetected by the instrumentation code for that stack entity. If so, theentry is highlighted. Each of the errors detected is associated with thestack entry. If the user sees a highlighted stack entry, the user canright click and get a list of errors that occurred in that stack entry.The errors appear in the order that they occurred. The user can navigateto the error location by clicking on one of the errors.

FIG. 7 illustrates a block diagram of a method 700 for debugging theinstrumented executable, according to one embodiment. The method 700begins at step 705 when the instrumented executable is executed. Atdecision block 710, the debugger determines whether an error generatedby the instrumented code occurred. If an error occurred, at step 715 arecord of the error is created. The log component 320 updates the debuglog 325 with that error. The error is tied back to the stack frame ofthe routine that was being executed when the error occurred. At decisionblock 720, it is determined whether a breakpoint was hit. If abreakpoint was hit, at block 725 execution is halted, and the developercan view the error and any errors for the routines within the stackframe that were executed. The error may be, for example, a dynamicanalysis error associated with the current routine. If, however, abreakpoint was not hit, the method reverts back to step 702, and theinstrumented executable is executed until a breakpoint is hit.

FIG. 8 illustrates a method 800 for debugging instrumented code usingsimple data flow analysis, according to one embodiment. The method 800begins at step 805 when the instrumented executable is executed. Atdecision block 810, the processor determines whether the debuggerdetects a dynamic analysis error generated by the instrumented code. Ifthe debugger detects a dynamic analysis error, at step 815, the dataflow analysis component 315 scans the parameters passed to the routinefor the error. At decision block 820, the detection component 305determines whether a breakpoint set by the breakpoint component 310 washit. If a break point was hit, at step 825, execution is halted and thedeveloper can view the error and any other errors for the routineswithin the stack frame that were executed. The error may be, forexample, a dynamic analysis error associated with the current routine.If a break point was not hit, the method reverts to step 805, andexecution continues until a break point is hit.

FIG. 9 illustrates another method 900 for debugging the instrumentedcode using a dynamic flow analysis, according to one embodiment. Themethod 900 begins at step 905 when the instrumented executable isexecuted. At decision block 910, the processor determines whether thedebugger detects a dynamic analysis error generated by the instrumentedcode. If the debugger detects a dynamic analysis error, at step 915 thedata flow analysis component 315 uses data flow analysis on the detectederrors. At step 920, the data flow analysis component 315 builds a listnoting the errors detected in a stack frame. The log component 320updates the debug log 325 with that error. The error is tied back to thestack from the routine that was being executed when the error was hit.At decision block 925, the detection component 305 determines whether abreak point was hit. If a break point was hit, at step 930, execution ishalted and the developer can view the error and any other errors for theroutines within the stack frame that were executed. The error may be,for example, a dynamic analysis error associated with the currentroutine. If the break point was not hit, however, the method reverts tostep 905 and execution continues until a break point is hit.

FIG. 10 illustrates an example computing system 1000, according to oneembodiment. As shown, the computing system 1000 includes a computer 1002having a central processing unit (CPU) 1004, a memory 1006, storage1008, and a network interface 1012, each connected to a bus 1014. Thecomputing system 1000 also includes an I/O device 1016 (e.g., keyboardand mouse devices) connected to the computing system 1000. Further, incontext of this disclosure, the computing elements shown in thecomputing system 1000 may correspond to a physical computing system(e.g., a system in a date center) or may be a virtual computing instancewhen executing within a computing cloud.

The CPU 1004 retrieves and executes programming instructions stored inthe memory 1006 as well as stores and retrieves application dataresiding in the memory 1006. The bus 1014 is used to transmitprogramming instructions and application data between the CPU 1004,memory 1006, storage 1008, network interface 1012, and I/O device 1016.Note, CPU 1004 is included to be representative of a single CPU,multiple CPUs, a single CPU having multiple processing cores, and thelike. The memory 1006 is generally included to be representative of arandom access memory. The storage 1008 may be a disk drive storagedevice. Although shown as a single unit, the storage 1008 may be acombination of a fixed and/or removable storage devices, such as fixeddisc drives, removable memory cards, optical storage, network attachedstorage (NAS), or storage-area-network (SAN). The storage 1008 mayinclude settings 1024. The network interface 1012 may be any type ofnetwork communications allowing the computer 1002 to communicate withother computers via the network 1022.

The memory 1006 further includes a debugger 1018 and a dynamic analysistool 1020. The debugger 1018 is an application generally configured totest and/or debug other executables. The debugger 1018 allows thedeveloper to pinpoint anomalies that occur during runtime. For example,the debugger 110 can insert breakpoints at instances where a givenprocessing element crashes, sends data to an unintended targetprocessing element, etc.

The dynamic analysis tool 1020 is an application generally configured totest executables. The dynamic analysis tool 1020 provides a toolset thatimproves the reliability of executables by identifying difficult to findmemory errors, such as uninitialized memory access, buffer overflow, andimproper freeing of memory. An example of a dynamic analysis tool 1020is PurifyPlus™ offered by UNICOM. The dynamic analysis tool 1020 may beused in runtime or on an existing executable.

The descriptions of the various embodiments of the present inventionhave been presented for purposes of illustration, but are not intendedto be exhaustive or limited to the embodiments disclosed. Manymodifications and variations will be apparent to those of ordinary skillin the art without departing from the scope and spirit of the describedembodiments. The terminology used herein was chosen to best explain theprinciples of the embodiments, the practical application, or technicalimprovement over technologies found in the marketplace, or to enableothers of ordinary skill in the art to understand the embodimentsdisclosed herein.

As will be appreciated by one skilled in the art, aspects of the presentinvention may be embodied as a system, method, or computer programproduct. Accordingly, aspects of the present invention may take the formof an entirely hardware embodiment, an entirely software embodiment(including firmware, resident software, micro-code, etc.) or anembodiment combining software and hardware aspects that may allgenerally be referred to herein as a “circuit,” “module” or “system.”Furthermore, aspects of the present invention may take the form of acomputer program product embodied in one or more computer readablemedium(s) having computer readable program code embodied thereon.

Any combination of one or more computer readable medium(s) may beutilized. The computer readable medium may be a computer readable signalmedium or a computer readable storage medium. A computer readablestorage medium may be, for example, but not limited to, an electronic,magnetic, optical, electromagnetic, infrared, or semiconductor system,apparatus, or device, or any suitable combination of the foregoing. Morespecific examples (a non-exhaustive list) of the computer readablestorage medium would include the following: an electrical connectionhaving one or more wires, a portable computer diskette, a hard disk, arandom access memory (RAM), a read-only memory (ROM), an erasableprogrammable read-only memory (EPROM or Flash memory), an optical fiber,a portable compact disc read-only memory (CD-ROM), an optical storagedevice, a magnetic storage device, or any suitable combination of theforegoing. In the context of this document, a computer readable storagemedium may be any tangible medium that can contain, or store a programfor use by or in connection with an instruction execution system,apparatus, or device.

A computer readable signal medium may include a propagated data signalwith computer readable program code embodied therein, for example, inbaseband or as part of a carrier wave. Such a propagated signal may takeany of a variety of forms, including, but not limited to,electro-magnetic, optical, or any suitable combination thereof. Acomputer readable signal medium may be any computer readable medium thatis not a computer readable storage medium and that can communicate,propagate, or transport a program for use by or in connection with aninstruction execution system, apparatus, or device.

Program code embodied on a computer readable medium may be transmittedusing any appropriate medium, including but not limited to wireless,wireline, optical fiber cable, RF, etc., or any suitable combination ofthe foregoing.

Computer program code for carrying out operations for aspects of thepresent invention may be written in any combination of one or moreprogramming languages, including an object oriented programming languagesuch as Java, Smalltalk, C++ or the like and conventional proceduralprogramming languages, such as the “C” programming language or similarprogramming languages. The program code may execute entirely on theuser's computer, partly on the user's computer, as a stand-alonesoftware package, partly on the user's computer and partly on a remotecomputer or entirely on the remote computer or server. In the latterscenario, the remote computer may be connected to the user's computerthrough any type of network, including a local area network (LAN) or awide area network (WAN), or the connection may be made to an externalcomputer (for example, through the Internet using an Internet ServiceProvider).

Aspects of the present invention are described below with reference toflowchart illustrations and/or block diagrams of methods, apparatus(systems) and computer program products according to embodiments of theinvention. It will be understood that each block of the flowchartillustrations and/or block diagrams, and combinations of blocks in theflowchart illustrations and/or block diagrams, can be implemented bycomputer program instructions. These computer program instructions maybe provided to a processor of a general purpose computer, specialpurpose computer, or other programmable data processing apparatus toproduce a machine, such that the instructions, which execute via theprocessor of the computer or other programmable data processingapparatus, create means for implementing the functions/acts specified inthe flowchart and/or block diagram block or blocks.

These computer program instructions may also be stored in a computerreadable medium that can direct a computer, other programmable dataprocessing apparatus, or other devices to function in a particularmanner, such that the instructions stored in the computer readablemedium produce an article of manufacture including instructions whichimplement the function/act specified in the flowchart and/or blockdiagram block or blocks.

Embodiments of the invention may be provided to end users through acloud computing infrastructure. Cloud computing generally refers to theprovision of scalable computing resources as a service over a network.More formally, cloud computing may be defined as a computing capabilitythat provides an abstraction between the computing resource and itsunderlying technical architecture (e.g., servers, storage, networks),enabling convenient, on-demand network access to a shared pool ofconfigurable computing resources that can be rapidly provisioned andreleased with minimal management effort or service provider interaction.Thus, cloud computing allows a user to access virtual computingresources (e.g., storage, data, applications, and even completevirtualized computing systems) in “the cloud,” without regard for theunderlying physical systems (or locations of those systems) used toprovide the computing resources.

Typically, cloud computing resources are provided to a user on apay-per-use basis, where users are charged only for the computingresources actually used (e.g. an amount of storage space consumed by auser or a number of virtualized systems instantiated by the user). Auser can access any of the resources that reside in the cloud at anytime, and from anywhere across the Internet. In context of the presentinvention, a user may access applications (e.g., debugger or dynamicanalysis tool) or related data available in the cloud. For example, thedebugger and dynamic analysis tool could execute on a computing systemin the cloud, detect runtime errors, and provide those errors in aruntime environment in the cloud. In such a case, the dynamic analysistool could instrument an existing executable with additional programcode to detect dynamic analysis errors and store the instrumentedexecutable in the cloud so that the instrumented executable can later berun in a debug environment provide the runtime errors in the context ofa debug environment location in the cloud. Doing so allows a user toaccess this information from any computing system attached to a networkconnected to the cloud (e.g., the Internet).

The present invention may be a system, a method, and/or a computerprogram product. The computer program product may include a computerreadable storage medium (or media) having computer readable programinstructions thereon for causing a processor to carry out aspects of thepresent invention.

The computer readable storage medium can be a tangible device that canretain and store instructions for use by an instruction executiondevice. The computer readable storage medium may be, for example, but isnot limited to, an electronic storage device, a magnetic storage device,an optical storage device, an electromagnetic storage device, asemiconductor storage device, or any suitable combination of theforegoing. A non-exhaustive list of more specific examples of thecomputer readable storage medium includes the following: a portablecomputer diskette, a hard disk, a random access memory (RAM), aread-only memory (ROM), an erasable programmable read-only memory (EPROMor Flash memory), a static random access memory (SRAM), a portablecompact disc read-only memory (CD-ROM), a digital versatile disk (DVD),a memory stick, a floppy disk, a mechanically encoded device such aspunch-cards or raised structures in a groove having instructionsrecorded thereon, and any suitable combination of the foregoing. Acomputer readable storage medium, as used herein, is not to be construedas being transitory signals per se, such as radio waves or other freelypropagating electromagnetic waves, electromagnetic waves propagatingthrough a waveguide or other transmission media (e.g., light pulsespassing through a fiber-optic cable), or electrical signals transmittedthrough a wire.

Computer readable program instructions described herein can bedownloaded to respective computing/processing devices from a computerreadable storage medium or to an external computer or external storagedevice via a network, for example, the Internet, a local area network, awide area network and/or a wireless network. The network may comprisecopper transmission cables, optical transmission fibers, wirelesstransmission, routers, firewalls, switches, gateway computers, and/oredge servers. A network adapter card or network interface in eachcomputing/processing device receives computer readable programinstructions from the network and forwards the computer readable programinstructions for storage in a computer readable storage medium withinthe respective computing/processing device.

Computer readable program instructions for carrying out operations ofthe present invention may be assembler instructions,instruction-set-architecture (ISA) instructions, machine instructions,machine dependent instructions, microcode, firmware instructions,state-setting data, or either source code or object code written in anycombination of one or more programming languages, including an objectoriented programming language such as Java, Smalltalk, C++ or the like,and conventional procedural programming languages, such as the “C”programming language or similar programming languages. The computerreadable program instructions may execute entirely on the user'scomputer, partly on the user's computer, as a stand-alone softwarepackage, partly on the user's computer and partly on a remote computeror entirely on the remote computer or server. In the latter scenario,the remote computer may be connected to the user's computer through anytype of network, including a local area network (LAN) or a wide areanetwork (WAN), or the connection may be made to an external computer(for example, through the Internet using an Internet Service Provider).In some embodiments, electronic circuitry including, for example,programmable logic circuitry, field-programmable gate arrays (FPGA), orprogrammable logic arrays (PLA) may execute the computer readableprogram instructions by utilizing state information of the computerreadable program instructions to personalize the electronic circuitry,in order to perform aspects of the present invention.

Aspects of the present invention are described herein with reference toflowchart illustrations and/or block diagrams of methods, apparatus(systems), and computer program products according to embodiments of theinvention. It will be understood that each block of the flowchartillustrations and/or block diagrams, and combinations of blocks in theflowchart illustrations and/or block diagrams, can be implemented bycomputer readable program instructions.

These computer readable program instructions may be provided to aprocessor of a general purpose computer, special purpose computer, orother programmable data processing apparatus to produce a machine, suchthat the instructions, which execute via the processor of the computeror other programmable data processing apparatus, create means forimplementing the functions/acts specified in the flowchart and/or blockdiagram block or blocks. These computer readable program instructionsmay also be stored in a computer readable storage medium that can directa computer, a programmable data processing apparatus, and/or otherdevices to function in a particular manner, such that the computerreadable storage medium having instructions stored therein comprises anarticle of manufacture including instructions which implement aspects ofthe function/act specified in the flowchart and/or block diagram blockor blocks.

The computer readable program instructions may also be loaded onto acomputer, other programmable data processing apparatus, or other deviceto cause a series of operational steps to be performed on the computer,other programmable apparatus or other device to produce a computerimplemented process, such that the instructions which execute on thecomputer, other programmable apparatus, or other device implement thefunctions/acts specified in the flowchart and/or block diagram block orblocks.

The flowchart and block diagrams in the Figures illustrate thearchitecture, functionality, and operation of possible implementationsof systems, methods, and computer program products according to variousembodiments of the present invention. In this regard, each block in theflowchart or block diagrams may represent a module, segment, or portionof instructions, which comprises one or more executable instructions forimplementing the specified logical function(s). In some alternativeimplementations, the functions noted in the block may occur out of theorder noted in the figures. For example, two blocks shown in successionmay, in fact, be executed substantially concurrently, or the blocks maysometimes be executed in the reverse order, depending upon thefunctionality involved. It will also be noted that each block of theblock diagrams and/or flowchart illustration, and combinations of blocksin the block diagrams and/or flowchart illustration, can be implementedby special purpose hardware-based systems that perform the specifiedfunctions or acts or carry out combinations of special purpose hardwareand computer instructions.

While the foregoing is directed to embodiments of the present invention,other and further embodiments of the invention may be devised withoutdeparting from the basic scope thereof, and the scope thereof isdetermined by the claims that follow.

1-7. (canceled)
 8. A system, comprising: a processor; and a memorystoring program code, which, when executed on the processor, performs anoperation of enhancing debugging of an executable, the operationcomprising: instrumenting an executable with additional program code todetect run-time errors; and while running the instrumented executablewithin a debug environment: generating the run-time errors detected bythe additional program code, upon reaching a breakpoint, identifying anyof the run-time errors which occurred while executing a function inwhich the breakpoint is located, and transmitting an indication of theidentified run-time errors to the debugging environment.
 9. The systemof claim 8, wherein generating the run-time errors detected by theadditional program code in the context of a debugger comprises: creatinga log; responsive to an error occurring, updating a record of the errorin the log; and continuing to run the instrumented executable until thebreakpoint is hit.
 10. The system of claim 9, wherein the error is tiedback to a stack frame of a routine that was being executed when theerror occurred.
 11. The system of claim 8, wherein generating therun-time errors detected by the additional program code in the contextof a debugger comprises: scanning parameters passed to a routine in theinstrumented executable to detect the error.
 12. The system of claim 8,wherein generating the run-time errors detected by the additionalprogram code in the context of a debugger comprises: using data flowanalysis to detect errors in the instrumented executable.
 13. The systemof claim 8, wherein a dynamic analysis tool instruments the executablewith the additional program code to obtain program information about theexecutable.
 14. The system of claim 8, further comprising: setting debugparameters for running the instrumented executable within a debugenvironment.
 15. A computer program product for enhancing debugging ofan executable, the computer program product comprising: acomputer-readable storage medium having computer-readable program codeembodied therewith, the computer-readable program code comprising:computer-readable program code configured to instrument an executablewith additional program code to detect run-time errors and while runningthe instrumented executable within a debug environment:computer-readable program code configured to generate the run-timeerrors detected by the additional program code; computer-readableprogram code configured to identify any of the run-time errors whichoccurred while executing a function in which a breakpoint is locatedupon reaching the breakpoint; and computer-readable program codeconfigured to transmit an indication of the identified run-time errorsto the debugging environment.
 16. The computer program product of claim15, wherein generating the run-time errors detected by the additionalprogram code in the context of a debugger comprises: creating a log;responsive to an error occurring, updating a record of the error in thelog; and continuing to run the instrumented executable until thebreakpoint is hit.
 17. The computer program product of claim 16, whereinthe error is tied back to a stack frame of a routine that was beingexecuted when the error occurred.
 18. The computer program product ofclaim 15, wherein generating the run-time errors detected by theadditional program code in the context of a debugger comprises: scanningparameters passed to a routine in the instrumented executable to detectthe error.
 19. The computer program product of claim 15, whereingenerating the run-time errors detected by the additional program codein the context of a debugger comprises: using data flow analysis todetect errors in the instrumented executable.
 20. The computer programproduct of claim 15, wherein a dynamic analysis tool instruments theexecutable with the additional program code to obtain programinformation about the executable.